home *** CD-ROM | disk | FTP | other *** search
/ Amiga Magazin: Amiga-CD 1996 September & October / Amiga-CD 1996 #9-10.iso / demos / storm-c / stormwizard / example-source / c-source / manager / manager.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-01-19  |  17.6 KB  |  624 lines
  1. /* Der Ansatz für einen leistungsfähigen Dateimanager
  2.  
  3.    (geschrieben unter StormC V1.1)
  4.  
  5.    $VER:              1.0 (12.06.96)
  6.  
  7.    Autor:             Thomas Mittelsdorf
  8.  
  9.    © 1996 HAAGE & PARTNER Computer GmbH,  All Rights Reserved
  10.  
  11. */
  12.  
  13. #include    <stdio.h>
  14. #include    <stdlib.h>
  15. #include    <string.h>
  16.  
  17. #include    <clib/alib_protos.h>
  18. #include    <pragma/dos_lib.h>
  19. #include    <pragma/exec_lib.h>
  20. #include    <pragma/intuition_lib.h>
  21. #include    <pragma/utility_lib.h>
  22. #include    <pragma/wizard_lib.h>
  23.  
  24. #include    <exec/exec.h>
  25. #include    <exec/memory.h>
  26. #include    <intuition/gadgetclass.h>
  27. #include    <intuition/intuition.h>
  28. #include    <utility/utility.h>
  29. #include    <libraries/wizard.h>
  30.  
  31. struct Library *UtilityBase;
  32. struct Library *WizardBase;
  33.  
  34. APTR    MySurface;
  35. struct Screen *MyScreen;
  36.  
  37. struct Gadget *MyGadgets[88];
  38. struct WizardWindowHandle *MyWinHandle;
  39. struct Window *MyWindow;
  40.  
  41. struct MyWinExtension
  42. {
  43. };
  44. /* Diese Struktur wird für dann beim WZ_AllocWindowHandle angelegt        **
  45. ** und im Feld UserData eingetragen !  Wenn die Größe allerdings            **
  46. ** NULL ist, dann darf dieser Zeiger nicht benutzt werden     !!!                **
  47. ** Sie könnten zum Beispiel eine Node-Struktur einbauen und damit     **
  48. ** ihre Fensterhandles verketten.                                                                            */
  49.  
  50. #define DIRTYPE        0
  51. #define FILETYPE    1
  52.  
  53. #define LToggleID    3
  54. #define RToggleID 16
  55. #define LViewID        5
  56. #define RViewID        18
  57. #define    LStringID    14
  58. #define RStringID 27
  59. #define ParentID    43
  60. #define StatusID    85
  61. #define AnzeigeID 86
  62.  
  63. struct MyListNode
  64. {
  65.     struct WizardDefaultNode WNode;
  66.     char String[256];
  67.  
  68.     char FileName[256];
  69.  
  70.     int Type;
  71.     unsigned long FileSize;
  72. };
  73. /* Diese Liste beinhaltet alle wichtigen Daten für einen Eintrag und    **
  74. ** besitzt gleichzeitig die WizardListNode, die von den ListView`s         **
  75. ** bzw. in unserem Fall den MultiListViews verlangt wird.                            */
  76.  
  77. struct MinList DummyList;
  78. struct MinList LeftList;
  79. struct MinList RightList;
  80.  
  81. struct MinList *QuellList;
  82. struct MinList *ZielList;
  83.  
  84. struct Gadget *QuellGadget;
  85. struct Gadget *ZielGadget;
  86.  
  87. struct Gadget *QuellStringGadget;
  88. struct Gadget *ZielStringGadget;
  89.  
  90. struct Gadget    *QuellToggleGadget;
  91. struct Gadget *ZielToggleGadget;
  92.  
  93. unsigned long QuellAnzeigeWert,ZielAnzeigeWert;
  94.  
  95. char QString[256];
  96. char ZString[256];
  97.  
  98. char *QuellAnzeige=QString;
  99. char *ZielAnzeige=ZString;
  100.  
  101. struct FileInfoBlock fib;
  102.  
  103.  
  104. void ReadDirectoryList(STRPTR device,BOOL newKopf)
  105. {
  106.     BPTR mylock;
  107.  
  108.     WZ_LockWindow(MyWinHandle);
  109.  
  110.     if (mylock=Lock(device,SHARED_LOCK))
  111.     {
  112.         if (Examine(mylock,&fib))
  113.         {
  114.             QuellAnzeigeWert=0;
  115.  
  116.             if (newKopf)
  117.                 sprintf(QuellAnzeige,"%s: ( %ldk )",&fib.fib_FileName,fib.fib_Size>>10);
  118.  
  119.             SetGadgetAttrs(QuellGadget,MyWindow,0L,
  120.                                                                             WLISTVIEWA_List,&DummyList,
  121.                                                                             WLISTVIEWA_Top,FALSE,
  122.                                                                             TAG_DONE);
  123.  
  124.  
  125.             while (QuellList->mlh_Head->mln_Succ)
  126.             {
  127.                 struct MinNode *t=QuellList->mlh_Head;
  128.  
  129.                 Remove((struct Node *)t);
  130.                 FreeVec(t);
  131.             }; /* die alte geschichte löschen */
  132.  
  133.  
  134.             while (ExNext(mylock,&fib))
  135.             {
  136.                 struct MyListNode *NewNode;
  137.  
  138.                 if (NewNode=AllocVec(sizeof(MyListNode),MEMF_CLEAR|MEMF_PUBLIC))
  139.                 {
  140.                     BOOL    Ready=FALSE;
  141.  
  142.                     struct MyListNode *PredNode=(struct MyListNode *)QuellList->mlh_Head;
  143.  
  144.                     strcpy(NewNode->FileName,fib.fib_FileName);
  145.  
  146.                     WZ_InitNode(&NewNode->WNode.WizardNode,1,TAG_DONE);
  147.  
  148.  
  149.                     if (fib.fib_DirEntryType>=0)
  150.                     {
  151.                         NewNode->FileSize=0;
  152.                         NewNode->Type=DIRTYPE;
  153.  
  154.                         WZ_InitNodeEntry(&NewNode->WNode.WizardNode,0,WENTRYA_Type,WNE_TEXT,
  155.                                                                                             WENTRYA_TextPen,WZRD_HIGHLIGHTTEXTPEN,
  156.                                                                                             WENTRYA_TextSPen,WZRD_HIGHLIGHTTEXTPEN,
  157.                                                                                             WENTRYA_TextStyle,FS_NORMAL,
  158.                                                                                             WENTRYA_TextSStyle,FS_NORMAL,
  159.                                                                                             WENTRYA_TextString,NewNode->FileName,
  160.                                                                                             TAG_DONE);
  161.                     }
  162.                     else
  163.                     {
  164.                         NewNode->FileSize=fib.fib_Size;
  165.                         NewNode->Type=FILETYPE;
  166.  
  167.                             sprintf(NewNode->String,"%-28s %7ld",NewNode->FileName,NewNode->FileSize);
  168.  
  169.  
  170.                         WZ_InitNodeEntry(&NewNode->WNode.WizardNode,0,WENTRYA_Type,WNE_TEXT,
  171.                                                                                             WENTRYA_TextPen,WZRD_TEXTPEN,
  172.                                                                                             WENTRYA_TextSPen,WZRD_FILLTEXTPEN,
  173.                                                                                             WENTRYA_TextStyle,FS_NORMAL,
  174.                                                                                             WENTRYA_TextSStyle,FS_NORMAL,
  175.                                                                                             WENTRYA_TextString,NewNode->String,
  176.                                                                                             TAG_DONE);
  177.                     };
  178.  
  179.                     while (!Ready && PredNode->WNode.WizardNode.Node.mln_Succ)
  180.                     {
  181.                         if (NewNode->Type>=PredNode->Type)
  182.                         {
  183.                             if (NewNode->Type==PredNode->Type)
  184.                             {
  185.                                 if (Stricmp(NewNode->FileName,PredNode->FileName)<0)
  186.                                 {
  187.                                     PredNode=(struct MyListNode *)PredNode->WNode.WizardNode.Node.mln_Pred    ;
  188.                                     Ready=TRUE;
  189.                                 }
  190.                                 else
  191.                                     PredNode=(struct MyListNode *)PredNode->WNode.WizardNode.Node.mln_Succ;
  192.                             }
  193.                             else
  194.                                 PredNode=(struct MyListNode *)PredNode->WNode.WizardNode.Node.mln_Succ;
  195.                         }
  196.                         else
  197.                         {
  198.                             PredNode=(struct MyListNode *)PredNode->WNode.WizardNode.Node.mln_Pred;
  199.                             Ready=TRUE;
  200.                         }
  201.                     };
  202.  
  203.                     Insert((struct List *)QuellList,(struct Node *)NewNode,(struct Node *)PredNode);
  204.  
  205.                 }
  206.             };
  207.  
  208.             SetGadgetAttrs(QuellGadget,MyWindow,0L,WLISTVIEWA_List,QuellList,
  209.                                                                                         WLISTVIEWA_Top,FALSE,
  210.                                                                                         TAG_DONE);
  211.         }
  212.  
  213.         if (newKopf)
  214.             SetGadgetAttrs(QuellToggleGadget,MyWindow,0L,WTOGGLEA_Label,QuellAnzeige,
  215.                                                                             TAG_DONE);
  216.  
  217.         SetGadgetAttrs(QuellStringGadget,MyWindow,0L,WSTRINGA_String,device,
  218.                                                                             TAG_DONE);
  219.  
  220.         SetGadgetAttrs(MyGadgets[86],MyWindow,0L,WARGSA_Arg0,0,TAG_DONE);
  221.  
  222.         UnLock(mylock);
  223.     }
  224.     WZ_UnlockWindow(MyWinHandle);
  225. }
  226.  
  227.  
  228. void GoToDir(STRPTR addpath)
  229. {
  230.     char *Dir;
  231.     char NewDir[256];
  232.  
  233.     if (GetAttr(WSTRINGA_String,QuellStringGadget,(ULONG *)&Dir))
  234.     {
  235.         strcpy(NewDir,Dir);
  236.         AddPart(NewDir,addpath,256);
  237.  
  238.         ReadDirectoryList(NewDir,FALSE);
  239.     }
  240.  
  241. }
  242.  
  243. main()
  244. {
  245.     struct NewWindow *MyNewWindow;
  246.  
  247.     struct IntuiMessage *msg;
  248.  
  249.     ULONG MsgClass;
  250.     UWORD MsgGadgetID;
  251.  
  252.     APTR    GadgetHelpIAddress;
  253.     struct WizardWindowHandle *GadgetHelpWinHandle;
  254.  
  255.     struct DateStamp MyDateStamp;
  256.     struct ClockData MyClockData;
  257.  
  258.     ULONG FreeChip;
  259.     ULONG FreeFast;
  260.  
  261.     NewList((struct List *)&LeftList);
  262.     NewList((struct List *)&RightList);
  263.     NewList((struct List *)&DummyList);
  264.  
  265.     if (UtilityBase=OpenLibrary("utility.library",0L))
  266.     {
  267.         if (WizardBase=OpenLibrary("wizard.library",0L))
  268.         {
  269.             if (MyScreen=LockPubScreen(0L))
  270.             {
  271.                 if (MySurface=WZ_OpenSurface("manager.wizard",0L,TAG_DONE))
  272.                 {
  273.                         if (MyWinHandle=WZ_AllocWindowHandle(MyScreen,
  274.                                                                                                 sizeof(MyWinExtension),
  275.                                                                                                 MySurface,TAG_DONE))
  276.                         {
  277.                             if (MyNewWindow=WZ_CreateWindowObj(MyWinHandle,1L,WWH_GadgetArray,MyGadgets,
  278.                                                                                                                                 WWH_GadgetArraySize,sizeof(MyGadgets),
  279.                                                                                                                                 TAG_DONE))
  280.                             {
  281.                                 QuellList=&LeftList;
  282.                                 ZielList=&RightList;
  283.  
  284.                                 FreeChip=AvailMem(MEMF_CHIP)>>10;
  285.                                 FreeFast=AvailMem(MEMF_FAST)>>10;
  286.  
  287.                                 DateStamp(&MyDateStamp);
  288.                                 Amiga2Date(MyDateStamp.ds_Days*24*3600+MyDateStamp.ds_Minute*60+MyDateStamp.ds_Tick/50,&MyClockData);
  289.  
  290.                                 SetGadgetAttrs(MyGadgets[StatusID],0L,0L,WARGSA_Arg0,FreeChip,
  291.                                                                             WARGSA_Arg1,FreeFast,
  292.                                                                             WARGSA_Arg2,FreeChip+FreeFast,
  293.                                                                             WARGSA_Arg3,MyClockData.mday,
  294.                                                                             WARGSA_Arg4,MyClockData.month,
  295.                                                                             WARGSA_Arg5,MyClockData.year,
  296.                                                                             WARGSA_Arg6,MyClockData.hour,
  297.                                                                             WARGSA_Arg7,MyClockData.min,
  298.                                                                             WARGSA_Arg8,MyClockData.sec,
  299.                                                                             TAG_DONE);
  300.                                 SetGadgetAttrs(MyGadgets[LViewID],0L,0L,WLISTVIEWA_List,QuellList,
  301.                                                                                         TAG_DONE);
  302.                                 SetGadgetAttrs(MyGadgets[RViewID],0L,0L,WLISTVIEWA_List,ZielList,
  303.                                                                                         TAG_DONE);
  304.  
  305.                                 QuellGadget=MyGadgets[LViewID];
  306.                                 ZielGadget=MyGadgets[RViewID];
  307.  
  308.                                 QuellStringGadget=MyGadgets[LStringID];
  309.                                 ZielStringGadget=MyGadgets[RStringID];
  310.  
  311.                                 QuellToggleGadget=MyGadgets[LToggleID];
  312.                                 ZielToggleGadget=MyGadgets[RToggleID];
  313.  
  314.                                 MyNewWindow->LeftEdge=0;
  315.                                 MyNewWindow->TopEdge=MyScreen->BarHeight;
  316.                                 MyNewWindow->Width=MyScreen->Width;
  317.                                 MyNewWindow->Height=MyScreen->Height-MyScreen->BarHeight;
  318.  
  319.                                 if (MyWindow=WZ_OpenWindow(MyWinHandle,MyNewWindow,WA_AutoAdjust ,TRUE,
  320.                                                                                                                                     WA_MenuHelp,TRUE,
  321.                                                                                                                                     TAG_DONE))
  322.                                 {
  323.                                     MyWindow->UserData=(BYTE *)MyWinHandle;
  324.                                     /* Wir wollen es uns schliesslich einfach machen oder ? */
  325.  
  326.                                     HelpControl(MyWindow,HC_GADGETHELP);
  327.  
  328.                                     do
  329.                                     {
  330.                                         WaitPort(MyWindow->UserPort); /* Auf CloseWindow warten*/
  331.  
  332.                                         if (msg=(struct IntuiMessage *)GetMsg(MyWindow->UserPort))
  333.                                         {
  334.                                             MsgClass=msg->Class;
  335.  
  336.                                             switch (MsgClass)
  337.                                             {
  338.                                                 case IDCMP_IDCMPUPDATE:
  339.                                                     switch (MsgGadgetID=GetTagData(GA_ID,0,(struct TagItem *)msg->IAddress))
  340.                                                     {
  341.                                                         unsigned long TWert;
  342.                                                         struct MyListNode *SelNode;
  343.  
  344.                                                         case 30:        /* die ganzen Laufwerksknöpfe */
  345.                                                         case 31:
  346.                                                         case 32:
  347.                                                         case 33:
  348.                                                         case 34:
  349.                                                         case 35:
  350.                                                         case 36:
  351.                                                         case 37:
  352.                                                         case 38:
  353.                                                         case 39:
  354.                                                         case 40:
  355.                                                             ReadDirectoryList(WZ_GadgetConfig(MyWinHandle,MyGadgets[MsgGadgetID]),TRUE);
  356.                                                             break;
  357.  
  358.                                                         case LToggleID:              /* linkes Toggle */
  359.                                                             TWert=ZielAnzeigeWert;
  360.                                                             ZielAnzeigeWert=QuellAnzeigeWert;
  361.                                                             QuellAnzeigeWert=TWert;
  362.  
  363.                                                             QuellList=&LeftList;
  364.                                                             ZielList=&RightList;
  365.  
  366.                                                             QuellGadget=MyGadgets[LViewID];
  367.                                                             ZielGadget=MyGadgets[RViewID];
  368.  
  369.                                                             QuellStringGadget=MyGadgets[LStringID];
  370.                                                             ZielStringGadget=MyGadgets[RStringID];
  371.  
  372.                                                             QuellToggleGadget=MyGadgets[LToggleID];
  373.                                                             ZielToggleGadget=MyGadgets[RToggleID];
  374.  
  375.                                                             QuellAnzeige=QString;
  376.                                                             ZielAnzeige=ZString;
  377.  
  378.                                                             SetGadgetAttrs(MyGadgets[86],MyWindow,0L,
  379.                                                                 WARGSA_Arg0,QuellAnzeigeWert,TAG_DONE);
  380.                                                             break;
  381.  
  382.                                                         case RToggleID:                        /* rechtes Toogle */
  383.                                                             TWert=ZielAnzeigeWert;
  384.                                                             ZielAnzeigeWert=QuellAnzeigeWert;
  385.                                                             QuellAnzeigeWert=TWert;
  386.  
  387.                                                             ZielList=&LeftList;
  388.                                                             QuellList=&RightList;
  389.  
  390.                                                             ZielGadget=MyGadgets[LViewID];
  391.                                                             QuellGadget=MyGadgets[RViewID];
  392.  
  393.                                                             ZielStringGadget=MyGadgets[LStringID];
  394.                                                             QuellStringGadget=MyGadgets[RStringID];
  395.  
  396.                                                             ZielToggleGadget=MyGadgets[LToggleID];
  397.                                                             QuellToggleGadget=MyGadgets[RToggleID];
  398.  
  399.                                                             ZielAnzeige=QString;
  400.                                                             QuellAnzeige=ZString;
  401.  
  402.                                                             SetGadgetAttrs(MyGadgets[AnzeigeID],MyWindow,0L,
  403.                                                                 WARGSA_Arg0,QuellAnzeigeWert,TAG_DONE);
  404.                                                             break;
  405.  
  406.                                                         case LViewID:                                        /* linkes MultiView */
  407.                                                             if (QuellList!=&LeftList)
  408.                                                             {
  409.                                                                 TWert=ZielAnzeigeWert;
  410.                                                                 ZielAnzeigeWert=QuellAnzeigeWert;
  411.                                                                 QuellAnzeigeWert=TWert;
  412.  
  413.                                                                 QuellList=&LeftList;
  414.                                                                 ZielList=&RightList;
  415.  
  416.                                                                 QuellGadget=MyGadgets[LViewID];
  417.                                                                 ZielGadget=MyGadgets[RViewID];
  418.  
  419.                                                                 QuellStringGadget=MyGadgets[LStringID];
  420.                                                                 ZielStringGadget=MyGadgets[RStringID];
  421.  
  422.                                                                 QuellToggleGadget=MyGadgets[LToggleID];
  423.                                                                 ZielToggleGadget=MyGadgets[RToggleID];
  424.  
  425.                                                                 QuellAnzeige=QString;
  426.                                                                 ZielAnzeige=ZString;
  427.  
  428.                                                                 SetGadgetAttrs(QuellToggleGadget,MyWindow,0L,
  429.                                                                     WTOGGLEA_Checked,TRUE,TAG_DONE);
  430.  
  431.                                                                 SetGadgetAttrs(ZielToggleGadget,MyWindow,0L,
  432.                                                                     WTOGGLEA_Checked,FALSE,TAG_DONE);
  433.  
  434.                                                                 SetGadgetAttrs(MyGadgets[AnzeigeID],MyWindow,0L,
  435.                                                                     WARGSA_Arg0,QuellAnzeigeWert,TAG_DONE);
  436.                                                             }
  437.  
  438.                                                             SelNode=(struct MyListNode *)
  439.                                                                 WZ_GetNode(QuellList,GetTagData(WLISTVIEWA_Selected,0,msg->IAddress));
  440.  
  441.                                                             if (!GetTagData(WLISTVIEWA_DoubleClick,FALSE,msg->IAddress))
  442.                                                             {
  443.                                                                 if (SelNode->Type==FILETYPE)
  444.                                                                 {
  445.                                                                     if (SelNode->WNode.WizardNode.Flags&WNF_SELECTED)
  446.                                                                         QuellAnzeigeWert+=SelNode->FileSize;
  447.                                                                     else
  448.                                                                         QuellAnzeigeWert-=SelNode->FileSize;
  449.  
  450.                                                                         SetGadgetAttrs(MyGadgets[AnzeigeID],MyWindow,0L,
  451.                                                                             WARGSA_Arg0,QuellAnzeigeWert,TAG_DONE);
  452.                                                                 }
  453.                                                             }
  454.                                                             else
  455.                                                                 if (SelNode->Type==DIRTYPE)
  456.                                                                     GoToDir(SelNode->FileName);
  457.  
  458.                                                             break;
  459.  
  460.                                                         case RViewID:                                    /*rechtes MultiView */
  461.                                                             if (QuellList!=&RightList)
  462.                                                             {
  463.                                                                 TWert=ZielAnzeigeWert;
  464.                                                                 ZielAnzeigeWert=QuellAnzeigeWert;
  465.                                                                 QuellAnzeigeWert=TWert;
  466.  
  467.                                                                 ZielList=&LeftList;
  468.                                                                 QuellList=&RightList;
  469.  
  470.                                                                 ZielGadget=MyGadgets[LViewID];
  471.                                                                 QuellGadget=MyGadgets[RViewID];
  472.  
  473.                                                                 ZielStringGadget=MyGadgets[LStringID];
  474.                                                                 QuellStringGadget=MyGadgets[RStringID];
  475.  
  476.                                                                 ZielToggleGadget=MyGadgets[LToggleID];
  477.                                                                 QuellToggleGadget=MyGadgets[RToggleID];
  478.  
  479.                                                                 ZielAnzeige=QString;
  480.                                                                 QuellAnzeige=ZString;
  481.  
  482.                                                                 SetGadgetAttrs(QuellToggleGadget,MyWindow,0L,WTOGGLEA_Checked,TRUE,
  483.                                                                                                                                         TAG_DONE);
  484.                                                                 SetGadgetAttrs(ZielToggleGadget,MyWindow,0L,WTOGGLEA_Checked,FALSE,
  485.                                                                                                                                         TAG_DONE);
  486.                                                                 SetGadgetAttrs(MyGadgets[AnzeigeID],MyWindow,0L,
  487.                                                                     WARGSA_Arg0,QuellAnzeigeWert,TAG_DONE);
  488.                                                             }
  489.  
  490.                                                             SelNode=(struct MyListNode *)
  491.                                                                 WZ_GetNode(QuellList,GetTagData(WLISTVIEWA_Selected,0,msg->IAddress));
  492.  
  493.                                                             if (!GetTagData(WLISTVIEWA_DoubleClick,FALSE,msg->IAddress))
  494.                                                             {
  495.                                                                 if (SelNode->Type==FILETYPE)
  496.                                                                 {
  497.                                                                     if (SelNode->WNode.WizardNode.Flags&WNF_SELECTED)
  498.                                                                         QuellAnzeigeWert+=SelNode->FileSize;
  499.                                                                     else
  500.                                                                         QuellAnzeigeWert-=SelNode->FileSize;
  501.  
  502.                                                                         SetGadgetAttrs(MyGadgets[AnzeigeID],MyWindow,0L,
  503.                                                                             WARGSA_Arg0,QuellAnzeigeWert,TAG_DONE);
  504.                                                                 }
  505.                                                             }
  506.                                                             else
  507.                                                                 if (SelNode->Type==DIRTYPE)
  508.                                                                     GoToDir(SelNode->FileName);
  509.  
  510.                                                             break;
  511.  
  512.                                                         case ParentID:
  513.                                                             {
  514.                                                                 char NewDir[256],*Dir;
  515.  
  516.                                                                 if (GetAttr(WSTRINGA_String,QuellStringGadget,(ULONG *)&Dir))
  517.                                                                     {
  518.                                                                         strcpy(NewDir,Dir);
  519.  
  520.                                                                         *(PathPart(NewDir))=0;
  521.                                                                         ReadDirectoryList(NewDir,FALSE);
  522.                                                                     }
  523.                                                             }
  524.                                                             break
  525.                                                     }
  526.                                                     break;
  527.  
  528.                                                 case IDCMP_MENUPICK:
  529.  
  530.                                                     switch(msg->Code)
  531.                                                     {
  532.                                                         case FULLMENUNUM(0,0,-1):
  533.                                                             {
  534.                                                                 ULONG Dummy;
  535.  
  536.                                                                 WZ_LockWindow(MyWinHandle);
  537.  
  538.                                                                 WZ_EasyRequestArgs(MySurface,MyWindow,1L,&Dummy);
  539.  
  540.                                                                 WZ_UnlockWindow(MyWinHandle);
  541.                                                             }
  542.                                                             break;
  543.  
  544.                                                         case FULLMENUNUM(0,2,-1):
  545.                                                             MsgClass=IDCMP_CLOSEWINDOW;
  546.                                                             break;
  547.                                                     }
  548.                                                     break;
  549.  
  550.                                                 case IDCMP_MENUHELP :
  551.                                                     SetWindowTitles(MyWindow,WZ_MenuHelp(MyWinHandle,msg->Code),(char *)-1L);
  552.                                                     Delay(50L);
  553.                                                     break;
  554.  
  555.                                                 case IDCMP_GADGETHELP:
  556.                                                     if (msg->IAddress)
  557.                                                     {
  558.                                                             SetWindowTitles(MyWindow,WZ_GadgetHelp(MyWinHandle,msg->IAddress),(char *)-1L);
  559.                                                     }
  560.                                                     break;
  561.                                                 case IDCMP_MOUSEMOVE:
  562.                                                     /* Falls wir unter 2.0 oder 2.1 laufen !!! */
  563.                                                     if (WZ_GadgetHelpMsg(MyWinHandle,&GadgetHelpWinHandle,&GadgetHelpIAddress,msg->MouseX,msg->MouseY,0))
  564.                                                         {
  565.                                                             SetWindowTitles(MyWindow,WZ_GadgetHelp(GadgetHelpWinHandle,GadgetHelpIAddress),(char *)-1L);
  566.                                                         }
  567.                                                     break;
  568.                                                 case IDCMP_INTUITICKS:
  569.  
  570.                                                             FreeChip=AvailMem(MEMF_CHIP)>>10;
  571.                                                             FreeFast=AvailMem(MEMF_FAST)>>10;
  572.  
  573.                                                             DateStamp(&MyDateStamp);
  574.                                                             Amiga2Date(MyDateStamp.ds_Days*24*3600+MyDateStamp.ds_Minute*60+(MyDateStamp.ds_Tick/50),&MyClockData);
  575.  
  576.                                                             SetGadgetAttrs(MyGadgets[StatusID],MyWindow,0L,
  577.                                                                             WARGSA_Arg0,FreeChip,
  578.                                                                             WARGSA_Arg1,FreeFast,
  579.                                                                             WARGSA_Arg2,FreeChip+FreeFast,
  580.                                                                             WARGSA_Arg3,MyClockData.mday,
  581.                                                                             WARGSA_Arg4,MyClockData.month,
  582.                                                                             WARGSA_Arg5,MyClockData.year,
  583.                                                                             WARGSA_Arg6,MyClockData.hour,
  584.                                                                             WARGSA_Arg7,MyClockData.min,
  585.                                                                             WARGSA_Arg8,MyClockData.sec,
  586.                                                                             TAG_DONE);
  587.                                                             break;
  588.  
  589.                                             }
  590.                                             ReplyMsg((struct Message *)msg);
  591.                                         }
  592.                                     } while (MsgClass != IDCMP_CLOSEWINDOW);
  593.  
  594.                                 WZ_CloseWindow(MyWinHandle);
  595.                             }
  596.  
  597.                             while (QuellList->mlh_Head->mln_Succ)
  598.                             {
  599.                                 struct MinNode *t=QuellList->mlh_Head;
  600.  
  601.                                 Remove((struct Node *)t);
  602.                                 FreeVec(t);
  603.                             };
  604.  
  605.                             while (ZielList->mlh_Head->mln_Succ)
  606.                             {
  607.                                 struct MinNode *t=ZielList->mlh_Head;
  608.  
  609.                                 Remove((struct Node *)t);
  610.                                 FreeVec(t);
  611.                             };
  612.                         }
  613.                         WZ_FreeWindowHandle(MyWinHandle)
  614.                     }
  615.                     WZ_CloseSurface(MySurface);
  616.                 }
  617.                 UnlockPubScreen(0L,MyScreen);
  618.             }
  619.             CloseLibrary(WizardBase);
  620.         }
  621.         CloseLibrary(UtilityBase);
  622.     }
  623. }
  624.